﻿using DeHeng_Mes.Constant;
using DeHeng_Mes.Dao;
using DeHeng_Mes.Model.Boss;
using DeHeng_Mes.Model.Table;
using DeHeng_Mes.Utils;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace DeHeng_Mes.Thread
{
    public class HourOperationToFactoryMes
    {
        private ProduceDao produceDao = new ProduceDao();
        public async Task Put()
        {
            Tools.ProduceLogText("小时产量推送状态检测线程启动！");
            while (true)
            {
                try
                {
                    Tools.ProduceLogText("正在检测小时产量推送状态");
                    // 判断是否存在未推送的小时产量数据
                    List<ProductionOperation> productionOperationAll = produceDao.GetAll();

                    // 初始化容器
                    Dictionary<string, List<ProductionOperation>> orderType = new Dictionary<string, List<ProductionOperation>>();

                    // 根据单号分类
                    foreach (var productionOperation in productionOperationAll)
                    {
                        // 判断是否包含该工单号的Key
                        if (!orderType.TryGetValue(productionOperation.OrderId, out List<ProductionOperation> production))
                            // 不包含添加Key与Value
                            orderType.Add(productionOperation.OrderId, new List<ProductionOperation>() { productionOperation });
                        else
                            // 包含Key，将数据添加Value的List中
                            production.Add(productionOperation);
                    }

                    // 包装数据推送
                    if (orderType != null && orderType.Count > 0)
                    {
                        Tools.ProduceLogText($"检测到{orderType.Count}条小时产量推送数据未成功推送，正在构建数据尝试再次推送...");

                        // 初始化推送Mes的数据容器
                        List<BossProductionHour> bossProductionHours = new List<BossProductionHour>();

                        // 构建数据
                        foreach (var productionOperations in orderType)
                        {
                            foreach (var productionOperation in productionOperations.Value)
                            {
                                // 存在数据，构建Mes可以接收的数据,初始化List
                                List<BossDeviceFault> bossDeviceFaults = new List<BossDeviceFault>();

                                // 获取小时时段
                                var timePeriod = productionOperation.TimeInterval;

                                // 转换格式
                                timePeriod = Tools.ConvertToHourRange(timePeriod);

                                // 获取开始时间与结束时间
                                string[] times = timePeriod.Split('-');

                                // 获取时间段内的报警数据
                                List<DeviceFault> deviceFaults = Tools.ErrorMessageInTime(int.Parse(times[0]), int.Parse(times[1]), productionOperation.Operation);

                                // 构建数据
                                // 构建报警数据
                                foreach (var deviceFault in deviceFaults)
                                {
                                    var bossDeviceFault = new BossDeviceFault()
                                    {
                                        DeviceId = deviceFault.DeviceId,
                                        FaultMessage = deviceFault.FaultMessage,
                                        FaultTime = decimal.Parse(deviceFault.FaultTime),
                                        FaultType = deviceFault.FaultType,
                                        StopStartTime = deviceFault.StopStartTime.ToString(),
                                        StopEndTime = deviceFault.StopEndTime.ToString()
                                    };
                                    bossDeviceFaults.Add(bossDeviceFault);
                                }

                                // 构建数据，并且推送数据
                                var bossProductionHour = new BossProductionHour()
                                {
                                    Operation = productionOperation.Operation,
                                    OrderId = productionOperation.OrderId,
                                    NowTime = timePeriod,
                                    Produce = decimal.Parse(productionOperation.Produce),
                                    ProduceNg = decimal.Parse(productionOperation.ProduceNg),
                                    TimeLong = decimal.Parse(productionOperation.TimeLong),
                                    DeviceFaults = bossDeviceFaults
                                };

                                bossProductionHours.Add(bossProductionHour);
                            }
                            // 调用接口推送数据
                            BossMessager bossMessager = await PutMes.LineMesToMes(bossProductionHours, SystemConstant.ProduceHourUrl, $"工序产量报工任务，订单号为：{productionOperations.Key}，推送");

                            // 判断推送状态进一步操作
                            if (bossMessager != null && bossMessager.code == 200)
                            {
                                // 推送成功,删除相关数据
                                foreach (var bossProductionHour in bossProductionHours)
                                {
                                    produceDao.DeleteOperation(bossProductionHour.OrderId, bossProductionHour.Operation);
                                }
                            }
                            bossProductionHours.Clear(); // 清空当前订单的数据容器，避免影响下个订单
                        }
                    }
                    else
                    {
                        Tools.ProduceLogText("小时产量推送状态检测线程未检测到需要推送的数据");
                    }
                }
                catch (Exception ex)
                {
                    Tools.ProduceLogTextError($"小时产量推送状态检测线程异常，原因是：{ex.Message}");
                }
                // 十分钟检测一次
                await Task.Delay(600000);
            }
        }
    }
}
